home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c-part1 / 8357 < prev    next >
Encoding:
Text File  |  1996-08-05  |  3.8 KB  |  88 lines
  1. Newsgroups: comp.lang.c
  2. Path: news.sprintlink.net!eskimo!scs
  3. From: scs@eskimo.com (Steve Summit)
  4. Subject: Re: more problems with qsort
  5. X-Nntp-Posting-Host: eskimo.com
  6. Message-ID: <DnpBFK.7nv@eskimo.com>
  7. Sender: news@eskimo.com (News User Id)
  8. Organization: schmorganization
  9. References: <4h0j9e$ng5@clarknet.clark.net> <4h81m0$avr@solutions.solon.com> <4hba5n$2ga@clarknet.clark.net>
  10. Date: Sun, 3 Mar 1996 17:04:30 GMT
  11.  
  12. In article <4hba5n$2ga@clarknet.clark.net>, yom@clark.net writes:
  13. > In article <4h81m0$avr@solutions.solon.com>, seebs@solutions.solon.com 
  14. > says...
  15. >> In article <4h0j9e$ng5@clarknet.clark.net>, yom <yom@clark.net> wrote:
  16. >> >And your compare function must be defined like this:
  17. >> >int compare(char **a,char **b) {return strcmp(*a,*b);}
  18. >>
  19. >> No, it really mustn't.  It must be defined like this:
  20. >> int compare(const void *a, const void *b) {
  21. >>        return strcmp(*(char **) a, *(char **) b);
  22. >> }
  23. > 
  24. > Well I disagree on this one. Results of 1) defining the compare 
  25. > function that takes two char** arguments and casting the function call 
  26. > to qsort and 2) defining the compare function that takes two void* 
  27. > arguments and casting the arguments to char ** in strcmp call are
  28. > identical.
  29.  
  30. The *results* *on your system* may have been identical, but the
  31. two code fragments most certainly are not.
  32.  
  33. If I may take the liberty of quoting from "C Programming FAQs:
  34. Frequently Asked Questions", Addison-Wesley, 1996:
  35.  
  36.     To understand why the curious pointer conversions in a qsort
  37.     comparison function are necessary (and why a cast of the
  38.     function pointer when calling qsort() can't help), it's useful
  39.     to think about how qsort() works.  qsort() doesn't know
  40.     anything about the type or representation of the data being
  41.     sorted: it just shuffles around little chunks of memory.
  42.     (All it knows about the chunks is their size, which you
  43.     specify in qsort()'s third argument.)  To determine whether
  44.     two chunks need swapping, qsort() calls your comparison
  45.     function.  (To swap them, it uses the equivalent of memcpy().)
  46.  
  47.     Since qsort() deals in a generic way with chunks of memory of
  48.     unknown type, it uses generic pointers (void *) to refer to
  49.     them.  When qsort() calls your comparison function, it passes
  50.     as arguments two generic pointers to the chunks to be
  51.     compared.  Since it passes generic pointers, your comparison
  52.     function must *accept* generic pointers, and convert the
  53.     pointers back to their appropriate type before manipulating
  54.     them (i.e. before performing the comparison).  A void pointer
  55.     is not the same type as a structure pointer, and on some
  56.     machines it may have a different size or representation
  57.     (which is why these casts are required for correctness).
  58.  
  59.     If you were sorting an array of structures, and had a
  60.     comparison function accepting structure pointers:
  61.  
  62.         int mywrongstructcmp(struct mystruct *, struct mystruct *);
  63.  
  64.     and if you called qsort() as
  65.  
  66.         qsort(dates, ndates, sizeof(struct mystruct),
  67.             (int (*)(const void *, const void *))mywrongstructcmp);
  68.                                 /* WRONG */
  69.  
  70.     the cast (int (*)(const void *, const void *)) would do
  71.     nothing except perhaps silence the message from the compiler
  72.     telling you that this comparison function may *not* work with
  73.     qsort().  The implications of any cast you use when calling
  74.     qsort will have been forgotten by the time qsort() gets around
  75.     to calling your comparison function: it will call them with
  76.     const void * arguments, so that is what your function must
  77.     accept.  No prototype mechanism exists which could operate
  78.     down inside qsort() to convert the void pointers to struct
  79.     mystruct pointers just before calling mywrongstructcmp().
  80.  
  81.     In general, it is a bad idea to insert casts just to "shut the
  82.     compiler up."  Compiler warnings are usually trying to tell
  83.     you something, and unless you really know what you're doing,
  84.     you ignore or muzzle them at your peril.  See also question 4.9.
  85.  
  86.                         Steve Summit
  87.                         scs@eskimo.com
  88.